• 专利附录
  • 专利说明
  • 权利要求
  • 类似技术
  • 同族专利
  • 引用文献
  • 法律状态
  • 优先权
    • 专利摘要:
    A method for detecting stack overflows comprising the following steps: A. storing in at least one dedicated register at least one data item chosen from: a data item (SPHaut) indicative of a maximum value authorized for a stack pointer, and a piece of data ( SPBas) indicative of a minimum value allowed for said stack pointer; B. performing a comparison between a current value (SP) or past (SPMin, SPMax) said pile pointer and said or each said data; and C. generating a stack overflow exception if said comparison indicates that said current or past value of said stack pointer is greater than said maximum allowed value or less than said minimum allowed value. Processor for the implementation of such a method.
    公开号:FR3013869A1
    申请号:FR1302695
    申请日:2013-11-22
    公开日:2015-05-29
    发明作者:Philippe Grossi；Dominique David；Francois Brun
    申请人:Thales SA；
    IPC主号:
    专利说明:

    [0001] The invention relates to a stack overflow detection method and to a processor for the implementation of a method for detecting stack overflows and a processor for implementing such a method. such a method. Programs written in advanced languages (C, C ++, ADA, etc.) require stacks of data to isolate the local variables of each function. Generally, for a given thread or thread, the stack is unique and grows with each nesting of functions, and then narrows when a function ends (returns). The memory of a computer generally stores a plurality of stacks, one for each process or thread. A problem frequently encountered with stacks is the overflow of the space allocated to one of them, mainly because of programming errors (unbounded recursive loops, unexpected connections, etc.) or functional defects. (poor stack size analysis, insufficient memory allocation, etc.). Overflows can also occur when using data whose size is known only at compile time (constructions with unconstrained types, mainly in ADA). When such an overflow occurs, a running process writes out of the memory area that is allocated to its stack, most often in the area allocated to the stack of another process. Such a problem is all the more difficult to detect and analyze when it occurs late, when the process whose stack has been corrupted is activated. For reasons of optimization of the generated code, the stack overflow is conventionally not managed by the compilers. In the past, some ADA compilers stored in a generic register a maximum allowable value for the stack pointer and they checked after the prologue of each function - so just after the stack allocation - that the stack pointer did not have exceeded this maximum allowable value. This solution was expensive in execution time and did not provide total protection against overflow risks. In addition, it did not provide any help to the programmer to size the batteries in order to avoid overflow errors. Another known method of the prior art for managing overflow errors is to use memory management units (MMUs) generally present in central processing units (CPUs). Central processing unit). The principle of this technique is to create a guard space around the memory area allocated to the stack, ie a small space (usually 4kB) before and after the stack area, including access to read / writing is forbidden. When the stack pointer overflows, the application tries to read or write in this forbidden zone and produces a page fault (program exception). This technique has several disadvantages: it requires a MMU, which is a heavy hardware unit, which is not present in all the processors and which is notably absent in many "embedded" processors; - the programming of the MMU is heavy and constraining (for this reason, this unit is usually deactivated for most applications); the protection obtained is not absolute: if, for example, the local stack of a function reserves a large amount of unexploited memory, it is possible to pass over the guard space and to continue in a space whose access is allowed although not allocated to the stack. It should be noted, furthermore, that MMUs are not intended for such an application, which constitutes a kind of "diversion". In order to assist in sizing the batteries, it is also known to write in the memory cells allocated to the stack a known pattern. After running a test program, the memory is examined to determine what "level" of the stack this pattern has been overwritten by write operations. This technique is cumbersome to implement and can only be applied in the development phase. It does not manage, or even detect overflow, but reduce the likelihood that they will occur by allowing memory allocation better suited to the actual process requirements. The invention aims to remedy at least some of the aforementioned drawbacks of the prior art. More specifically, the object of the invention is to provide a method for detecting stack overflows that is simple to implement, not significantly slowing the execution of programs and not requiring complex hardware units. A method according to the invention implements both hardware - relatively simple - and software means. According to one embodiment of the invention, the stack overflows are detected as soon as they occur, which makes it possible to minimize their consequences. According to another embodiment of the invention, the method furthermore provides data that can assist a developer in sizing the cells. These two embodiments can advantageously be combined. The invention also aims to provide a processor comprising hardware means for implementing such a method. An object of the invention is a method of detecting stack overflows comprising the following steps: A. storing in at least one dedicated register at least one data item chosen from: a data item indicative of a maximum value authorized for a pointer of stack, and indicative data of a minimum value allowed for said stack pointer; B. performing a comparison between a current or past value of said stack pointer and said or each said data item; and C. generating a stack overflow exception if said comparison indicates that said current or past value of said stack pointer is greater than said maximum allowed value or less than said minimum allowed value. According to different embodiments of the invention: Said step A. may comprise the storage in two dedicated registers of a data indicative of a maximum value authorized for a stack pointer and a data item indicative of a value. minimum allowed for said stack pointer; and said step B. comprises at least one comparison between the value of said stack pointer and each said datum. The method may also comprise the following steps: A1: store in at least one other dedicated register at least one data item chosen from: a data item indicative of a maximum value taken by a stack pointer during the execution of a process or thread, and indicative data of a minimum value taken by said stack pointer during the execution of said process or thread; BI: update said data during execution of said process or thread. Said step A1 can comprise the storage in two dedicated registers of a data item indicative of a maximum value taken by said stack pointer during the execution of said process or thread of execution and a data item indicative of a minimum value taken by said stack pointer during execution of said process or thread. Said step A1 can be implemented by an operating system during activation of said process or execution thread, and said step BI can be implemented by a hardware processing module during the execution of said process. or thread. Said step A. can be implemented by an operating system when activating a process or thread, and said steps B. and C. can be implemented by said operating system When switching the context for suspending said process or thread and activating another process or thread, and including at least one comparison selected from: a comparison between said indicative data of a the maximum value allowed for a stack pointer and said maximum value taken by said stack pointer when executing the process or thread being suspended; and a comparison between said indicative value of a minimum value allowed for a stack pointer and said minimum value taken by said stack pointer during execution of said process or thread being suspended. Said step A. can be implemented by an operating system when activating a process or thread, and said steps B. and C. can be implemented by a hardware processing module during the execution of said process or thread, said step B. comprising a comparison between a current value of said stack pointer and said or each said data. When activating a process or thread, said operating system can recover from the context of a process or thread or execution to activate said or each said data item to be stored in said or each said register; dedicated and, when switching the context for the suspension of said process or thread and activation of another process or thread, said operating system can save said or each said data stored in a said dedicated register in the context of said process or thread being suspended. The method may implement a first set of said dedicated registers and a second equivalent set of dedicated registers, and: when activating a process or thread for executing in user mode, at least said step A. may be implemented by an operating system operating in supervisor mode and using the dedicated registers or registers of said first set; and when activating a process or thread for executing in supervisor mode, at least said step A. may be implemented by an operating system operating in hypervisor mode and using the one or more dedicated registers of said second set. Another object of the invention is a processor for carrying out such a method comprising: a central unit; at least one register for storing a stack pointer; at least one dedicated register for storing at least one piece of data selected from: data indicative of a maximum value allowed for said stack pointer, and data indicative of a minimum value allowed for said stack pointer; and a hardware processing module configured to perform a comparison between a current value of said stack pointer and said or each said data, and to generate a stack overflow exception if said comparison indicates that said current value of said stack pointer is greater than said maximum value allowed or less than the minimum allowed value. Yet another object of the invention is a processor for implementing such a method comprising: a central unit; at least one register for storing a stack pointer; at least one dedicated register for storing at least one piece of data selected from: data indicative of a maximum value allowed for said stack pointer, and data indicative of a minimum value allowed for said stack pointer; and at least one dedicated register for storing at least one data item chosen from: a data item indicative of a maximum value taken by a stack pointer during the execution of a process or thread in progress, and a piece of data indicative of a minimum value taken by said stack pointer during execution of said current process or thread; and a hardware processing module configured to update said data during the execution of said process or thread. Other characteristics, details and advantages of the invention will emerge on reading the description given with reference to the appended drawings given by way of example and which represent, respectively: FIG. 1, a simplified block diagram of a processor according to one embodiment of the invention; FIG. 2, a flowchart of a material processing according to one embodiment of the invention; FIGS. 3A and 3B of the process flowcharts according to two embodiments of the invention, respectively implementing hardware detection and software detection of the stack overflows; and FIG. 4 is a diagram of organization of the memory of a computer implementing a method according to one embodiment of the invention. The processor P of FIG. 1 comprises - in a conventional manner - a central processing unit UC exchanging data with a memory MEM (which, in the case of the figure, is not part of the processor itself), a set of N "generic" registers R1 - RN and two registers for storing a pointer to a stack: RSP and SRSP, for the processes executed in user mode and in supervisor mode, respectively. The processor also comprises two sets of dedicated registers for detecting stack overflows: a first set comprising the registers RHaut, RBas, RMin and RMax, for the user mode and a second set comprising the registers SRHaut, SRBas, SRMin and SRMax, for supervisor mode; as well as a hardware processing module MMT represented as a separate component, but can in fact be integrated with the central unit. In the embodiment of FIG. 1, all the data exchanges are done via the central unit UC; alternatively, data exchanges could be carried out directly between the dedicated registers and the hardware processing module MMT and / or the memory MEM. Each of the dedicated registers must have a dimension at least equal to that of the SP / SSP stack pointer. The processor P may be single or multi-core and may be implemented as a dedicated integrated circuit or synthesized from programmable logic components such as CPLDs or FPGAs. The RHaut register (SRHaut in supervisor mode) is intended to contain a piece of data - indicated thereafter by SPHaut - indicative of a maximum value allowed for the stack pointer SP; in practice, it will most often be the maximum value of SP that does not produce a stack overflow "from above". The register RBas (SRBas in supervisor mode) is intended to contain data - indicated subsequently by SPBas - indicative of a minimum value allowed for the stack pointer SP; in practice, it will most often be the minimum value of SP that does not produce a stack overflow "from below". The SPHaut and SPBas values are initialized when allocating the stack. These values are not changed during the execution of a process or thread (in the following we will speak simply of "process"), but only during a context switch; this will be explained in detail later, with reference to FIGS. 3A and 3B. The RMax register (SRMax in supervisor mode) is intended to contain a piece of data - indicated subsequently by SPMax - indicative of a maximum value taken by the stack pointer SP during the execution of the process (in practice, it is will most often act on the maximum value itself). The RMin register (SRMin in supervisor mode) is intended to contain a piece of data - indicated subsequently by SPMin - indicative of a minimum value taken by the stack pointer SP during the execution of the process (in practice, it is will most often act on the minimum value itself). The values SPMax and SPMin are updated continuously during the execution of a process. It should be noted that a processor according to the invention does not necessarily have to include all the eight dedicated registers illustrated in FIG. 1. Indeed, different embodiments of a method according to the invention can use only a set of registers. (usually the first one, intended to manage overflows caused by processes executed in user mode), or even only an incomplete set, including only the pair of registers RHaut / RBas (or SRHaut / SRBas) or the pair RMax / RMin ( or SRMax / SRMin). On the other hand, if we know that a stack overflow can only reasonably occur "upwards", it may be sufficient to provide the RHaut register and / or the RMax register (SRHaut and / or SRMax if we are interested processes running in supervisor mode). Conversely, if we know that a stack overflow can only reasonably occur "downwards", it may be sufficient to provide the register RBas and / or the register 20 RMin (SRBas and / or SRMin if we are interested processes running in supervisor mode). It is understood that, at the limit, a single dedicated register may be sufficient for some particularly simple embodiments of the invention. Similarly, a method according to some embodiments of the invention may not use a hardware MMT processing module, but perform the detection of stack overflows in a software manner (in particular, by the operating system during a context switching) - the only unconventional hardware elements used being then the dedicated registers. In the embodiment of FIG. 1, the hardware module 30 for processing MMT performs the processes illustrated in FIG. 2. It is considered that, during the creation of the process in progress, the values SP, SPMin and SPMax have initialized by assigning them a SPINIT value corresponding to the "bottom" of the stack; if we use the most common convention, according to which we stack by decrementing SP, we have SPINIT = SPHaut. Then, at each cycle of the processor, it is checked whether the value of the stack pointer SP is lower than the current value of SPMin, stored in the RMin or SRMin register. If yes, SPMin is updated, and becomes equal to SP. Then, it is checked whether the value of the stack pointer SP is greater than the current value of SPMax, stored in the register RMax or SRMax. If yes, SPMax is updated, and becomes SP. These two comparison and assignment operations (in simplified embodiments, only one may be present) constitute the "Part I" of the processing. Then ("Part II" of the processing) it is checked whether SP> SPHaut or SP <SPBas (in simplified embodiments, a single comparison may be present). If any of these conditions are true, the module generates a stack overflow exception. Otherwise, the treatment starts again. The synthesis of a hardware module implementing such a treatment does not present any particular difficulty for the skilled person. In some embodiments, only part I of the treatment may be present. In such a case: either the detection of the overflows is carried out in software (see Figure 3B), or such detection is absent. In the latter case, the overflows 20 cause delayed malfunctions, as in the prior art; however, the saved values of SPMin and SPMax allow the developer to understand a posteriori the origin of these malfunctions and to remedy them. Even in the absence of overflow, studying the values of SPMin and SPMax at the end of the various processes makes it possible to optimize the memory allocation for the cells. In other embodiments, only Part II of the processing may be present, to ensure rapid detection of stack overflows. In this case, however, little information is available to assist a developer in sizing the batteries. FIG. 3A illustrates the operations performed by the processor P under the control of the operating system during the context switching that occurs when a process PR_1 is suspended and another process PR_2 is activated.
    [0002] Initially, the PR_1 process is running. Any overflows of its stack are detected by the hardware module MMT and managed by the service service of the operating system Gestion_dexordement_pile (PR_1); in addition, the values of SPMin and SPMax are constantly updated by this same processing module, as explained above. When PR_1 is to be suspended, the operating system stores the latest values of SPMin and SPMax, contained in the RMin and RMax dedicated registers in context variables PR_1.SPMin and PRI.SPMax. Then, SPMin and SPMax take their new values, from the variables PR_2.SPMin and PR2.SPMax contained in the context of PR_2; in addition, the values SPBas and SPHaut, stored in the context variables of PR_2 called PR_2.SPBas and PR_2SPHaut are loaded in the dedicated registers RBas and RHaut (the order of these operations is unimportant). Context switching then continues in a conventional manner. If the hardware processing module MMT is only configured to implement the part I of the processing (and, therefore, does not include the RHaut and RBas registers), the overflow detection can be performed in a software manner. In order not to slow down program execution excessively, this detection is then done only during the context switching, as illustrated by the flow chart of FIG. 3B. This figure shows that when the PR_1 process is to be suspended, the operating system compares SPMin to PR_1.SPBas and SPMax to PRI.SPHaut and, if applicable, raises an overflow exception (running the overflow handling service with PR_1 as a parameter). Then, as in the previous case, the current values of SPMin and SPMax are saved in the context of PR_1 (more precisely: in the region of the memory intended to save the data characterizing the context of PR_1) and their new values are loaded in the RMin and RMax registers from the context of PR_2. Context switching then continues in a conventional manner. Note that, in the embodiment of Figure 3A, the overflows are detected immediately by the hardware module MMT, even before an unwanted write takes place. In the embodiment of FIG. 3B, on the other hand, the overflows are detected only during the suspension of the process that caused the error, after data could have been potentially irreversibly damaged.
    [0003] It will be noted that, in all cases, the invention implements both hardware means (dedicated registers, MMT module) and software (operating system and compilers, the latter being responsible for determining the values of SPHaut and SPBas ). The use of a hardware module - and not a software module - allows the detection of stack overflows and / or to measure the actual use of the stack space by the processes without unduly slowing down their execution. In addition, hardware control is insensitive to software errors. The fact that the operating system is involved in controlling the overflows of ordinary processes (and not a program of the same order of privilege, as in the case of certain techniques known in the prior art) also contributes to the reliability of the technical aspect of the invention. FIGS. 3A and 3B refer to the case where the processes PR 1 and PR 2 are ordinary processes executed in user mode, but they also apply, mutatis mutandis, in the case of privileged processes executed in supervisor mode. ; in the latter case, the overflows processing is done in hypervisor mode. FIG. 4 illustrates the organization of the memory MEM during the implementation of a method according to the invention. From top to bottom, there is a region allocated to global data storage, the ST_PR1 stack allocated to the running PR_1 process, the ST_PR2 stack allocated to the PR_2 process that is suspended, the ST_OS stack allocated to the OS operating system and a "heap" for storing dynamic data. In the case of the stack ST_PR1, we see that SPMin = SPBas, which means that the stack pointer SP has reached - but not exceeded - the lower limit of the stack; on the other hand, SPMax <SPHaut, which means that the memory allocated to the stack has not been used completely; more precisely, in the example of the figure, 30% of the memory reserved for the stack of PR_1 is used (the percentage of memory used is 8% for the PR_2 process and 45% for OS). Because the process is running, these values are stored in the RMin, RBas, RSP, RMax, and RHaut registers, respectively. The values of SPHaut, SPBas, SPMax and SPMin are saved in the context of the PR_2 process, and more precisely in the variables PR_2.SPHaut, PR_2.SPBas, PR_2.SPMax, PR_2.SPMin respectively; these values will be loaded into the corresponding dedicated registers when the process is activated. As for the OS operating system, the values SPSHaut, 10 SPSBas, SPS, SPSMin and SPSMax are stored in the dedicated registers SRHaut, SRBas, SRSP, SRMin and SRMax, respectively. The reliability of the invention, its absence or quasi-absence of penalty in terms of execution time and the simplicity of the hardware and software means implemented make it particularly suitable for embedded applications, for example in avionics. In addition, the embedded processors have a relatively simple hardware and software architecture (operating systems), and are frequently made from programmable logic components. These features facilitate the modification of a pre-existing architecture to allow the implementation of the invention.
    权利要求:
    Claims (11)
    [0001]
    REVENDICATIONS1. A method for detecting stack overflows comprising the following steps: A. storing in at least one dedicated register (RHaut, RBas) at least one data item chosen from: a data item (SPHaut) indicative of a maximum value authorized for a stack pointer (SP), and a datum (SPBas) indicative of a minimum value allowed for said stack pointer; B. performing a comparison between a current value (SP) or past (SPMin, SPMax) of said stack pointer and said or each said data item; and C. generating a stack overflow exception if said comparison indicates that said current or past value of said stack pointer is greater than said maximum allowed value or less than said minimum allowed value.
    [0002]
    2. Method according to claim 1, wherein said step A. comprises the storage in two dedicated registers (RHaut, RBas) of a datum (SPHaut) indicative of a maximum value allowed for a stack pointer and a given datum. (SPBas) indicative of a minimum value allowed for said stack pointer; and said step B. comprises at least one comparison between the value of said stack pointer (SP) and each said data item.
    [0003]
    3. Method according to one of the preceding claims 25 also comprising the following steps: A1: store in at least one other dedicated register (RMax, RMin) at least one data selected from: a data indicative of a maximum value (SPMax) taken by a stack pointer (SP) during the execution of a process or thread, and data (SPMin) indicative of a minimum value taken by said stack pointer during execution said process or thread; B1: update said data during the execution of said process or thread.
    [0004]
    4. The method of claim 3 wherein said step A1 comprises storing in two dedicated registers (RMax, RMin) a datum (SPMax) indicative of a maximum value taken by said stack pointer (SP) during the executing said process or thread and a piece of data (SPMin) indicative of a minimum value taken by said stack pointer during the execution of said process or thread.
    [0005]
    5. Method according to one of claims 3 or 4 wherein said step A1 is implemented by an operating system (OS) during activation of said process or thread, and said step B1 is put implemented by a hardware processing module (MTM) during the execution of said process or thread. 15
    [0006]
    6. Method according to one of claims 3 to 5 wherein said step A. is implemented by an operating system when activating a process or thread, and said steps B. and C are implemented by said operating system during context switching for the suspension of said process or thread and the activation of another process or thread and comprise at least one comparison selected from : a comparison between said data indicative of a maximum value allowed for a stack pointer and said maximum value taken by said stack pointer during execution of the process or thread being suspended; and a comparison between said data indicative of a minimum value allowed for a stack pointer and said minimum value taken by said stack pointer during execution of said process or thread being suspended.
    [0007]
    7. Method according to one of claims 1 to 5 wherein said step A. is implemented by an operating system (OS) when activating a process or thread, and said steps B. and C. are implemented by a hardware processing module (MTM) during the execution of said process or thread, said step B. comprising a comparison between a current value of said stack pointer and said one or each said given.
    [0008]
    8. Method according to one of claims 5, 6 or 7 wherein, when activating a process or thread (PR_1), said operating system recovers from the context of a process or thread d executing to activate said or each said data item to be stored in said or each said dedicated register and, when switching the context for the suspension of said process or thread of execution and the activation of another process or thread o d execution (PR_2), said operating system saves said or each said data stored in a said dedicated register in the context of said process or thread being suspended.
    [0009]
    9. Method according to one of the preceding claims 15 implementing a first set of said dedicated registers (RHaut, RBas, RMax, RMin) and a second equivalent set (SRHaut, SRBas, SRMax, SRMin) of dedicated registers, wherein when activating a process or thread for executing in user mode, at least said step A. is implemented by an operating system operating in supervisor mode and in using the dedicated registers or registers of said first game; and when activating a process or thread for executing in supervisor mode, at least said step A. is implemented by an operating system operating in hypervisor mode and using the the dedicated registers of said second game.
    [0010]
    Processor (P) for carrying out a method according to claim 7 comprising: a CPU (UC); At least one register (RSP) for storing a stack pointer (SP); at least one dedicated register (RHaut, RBas) for storing at least one data item chosen from: data (SPHaut) indicative of a maximum value allowed for said stack pointer, and data item (SPBas) indicative of a minimum authorized value for said stack pointer; and a hardware processing module (MTM) configured to perform a comparison between a current value of said stack pointer and said or each said data, and to generate a stack overflow exception if said comparison indicates that said current value of said stack pointer is greater than said maximum allowed value or less than said minimum allowed value. 10
    [0011]
    11. Processor (P) for carrying out a method according to claim 7 comprising: a central unit (CPU); at least one register (RSP) for storing a stack pointer (SP); At least one dedicated register (RHaut, RBas) for storing at least one data item chosen from: data (SPHaut) indicative of a maximum value authorized for said stack pointer, and data item (SPBas) indicative of a value minimum allowed for said stack pointer; and at least one dedicated register (SPMax, SPMin) for storing at least one datum chosen from: a datum indicative of a maximum value taken by a stack pointer during the execution of a process or thread of execution in progress, and a data indicative of a minimum value taken by said stack pointer during execution of said process or thread in progress; and a hardware processing module (MTM) configured to update said data during the execution of said process or thread.
    类似技术:
    公开号 | 公开日 | 专利标题
    FR3013869A1|2015-05-29|METHOD FOR DETECTING BATTERY FLOWS AND PROCESSOR FOR IMPLEMENTING SUCH A METHOD
    US9946576B2|2018-04-17|Distributed workflow execution
    US7774636B2|2010-08-10|Method and system for kernel panic recovery
    FR2881239A1|2006-07-28|METHOD FOR MANAGING ACCESS TO SHARED RESOURCES IN A MULTI-PROCESSOR ENVIRONMENT
    US10162696B2|2018-12-25|Dependency monitoring
    WO2016011129A1|2016-01-21|Accurate static dependency analysis via execution-context type prediction
    US10019461B2|2018-07-10|Transparent and near-real time code deploys
    EP0637798B1|1999-10-27|Deadlock analysis method in an operating system
    FR2972545A1|2012-09-14|CONTROL STREAM CONTROL CONTROLLED BY PROGRAM INSTRUCTIONS
    EP1960934B1|2012-03-21|Method for making secure execution of an intermediate language software code in a portable appliance
    US9471583B2|2016-10-18|Data race analysis with improved detection filtering
    EP1881404A1|2008-01-23|Method for dynamic protection of data during intermediate language software execution in a digital device
    US20100275206A1|2010-10-28|Standalone software performance optimizer system for hybrid systems
    FR2994290A1|2014-02-07|SYSTEM FOR DETECTING MODIFICATION OF A SUB-PROGRAM CALL BATTERY
    EP2836913B1|2019-12-25|Device for generating a signature during execution of a program task, and method for comparing flows of execution
    US9158651B2|2015-10-13|Monitoring thread starvation using stack trace sampling and based on a total elapsed time
    CN104461880A|2015-03-25|Method for automatically detecting heap corruption in embedded system
    US9436575B2|2016-09-06|Selective profiling of applications
    FR3025036B1|2019-06-21|PROCESS FOR AUTOMATICALLY PROCESSING A SOURCE CODE FOR ITS AERONAUTICAL CERTIFICATION; COMPUTER PROGRAM PRODUCT
    JP2021533487A|2021-12-02|Systems and methods for parallel execution and comparison of related processes for fault protection
    CN108647113B|2022-02-18|Disaster recovery method and server
    FR2967275A1|2012-05-11|METHOD, COMPUTER PROGRAM AND DEVICE FOR SECURING INTERMEDIATE PROGRAMMING CODE FOR ITS EXECUTION BY A VIRTUAL MACHINE
    Carata et al.2013|{IPAPI}: Designing an Improved Provenance {API}
    CN109885489B|2020-07-21|Data race detection method and device in driver
    US10515029B2|2019-12-24|Conversion tool for moving from block-based persistence to byte-based persistence
    同族专利:
    公开号 | 公开日
    FR3013869B1|2016-01-01|
    US9513911B2|2016-12-06|
    US20150150024A1|2015-05-28|
    引用文献:
    公开号 | 申请日 | 公开日 | 申请人 | 专利标题
    US4835738A|1986-03-31|1989-05-30|Texas Instruments Incorporated|Register stack for a bit slice processor microsequencer|
    WO1999009469A1|1997-08-18|1999-02-25|Koninklijke Philips Electronics N.V.|Stack oriented data processing device|
    US4530049A|1982-02-11|1985-07-16|At&T Bell Laboratories|Stack cache with fixed size stack frames|
    KR20020028814A|2000-10-10|2002-04-17|나조미 커뮤니케이션즈, 인코포레이티드|Java hardware accelerator using microcode engine|
    US6526463B1|2000-04-14|2003-02-25|Koninklijke Philips Electronics N.V.|Dynamically selectable stack frame size for processor interrupts|
    US10353797B2|2006-12-29|2019-07-16|International Business Machines Corporation|Using memory tracking data to inform a memory map tool|
    KR101334172B1|2007-01-05|2013-11-28|삼성전자주식회사|Method and appratus for preventing stack overflow in embedded system|
    US7962729B2|2009-01-05|2011-06-14|International Business Machines Corporation|Dynamic runtime range checking of different types on a register using upper and lower bound value registers for the register|
    US9229721B2|2012-09-10|2016-01-05|Qualcomm Incorporated|Executing subroutines in a multi-threaded processing system|
    FR3013869B1|2013-11-22|2016-01-01|Thales Sa|METHOD FOR DETECTING BATTERY FLOWS AND PROCESSOR FOR IMPLEMENTING SUCH A METHOD|US10019395B2|2013-11-08|2018-07-10|Nxp Usa, Inc.|Processing system with stack management and method for stack management|
    FR3013869B1|2013-11-22|2016-01-01|Thales Sa|METHOD FOR DETECTING BATTERY FLOWS AND PROCESSOR FOR IMPLEMENTING SUCH A METHOD|
    US20160381050A1|2015-06-26|2016-12-29|Intel Corporation|Processors, methods, systems, and instructions to protect shadow stacks|
    US10394556B2|2015-12-20|2019-08-27|Intel Corporation|Hardware apparatuses and methods to switch shadow stack pointers|
    US10430580B2|2016-02-04|2019-10-01|Intel Corporation|Processor extensions to protect stacks during ring transitions|
    US9904485B2|2016-03-31|2018-02-27|Intel Corporation|Secure memory controller|
    CN107391252A|2016-05-16|2017-11-24|阿里巴巴集团控股有限公司|A kind of method for processing resource and device|
    US10649786B2|2016-12-01|2020-05-12|Cisco Technology, Inc.|Reduced stack usage in a multithreaded processor|
    US10114573B1|2017-04-26|2018-10-30|International Business Machines Corporation|Dynamic reduction of stack-overflow errors in a recursive data-serialization algorithm|
    CN109558734B|2018-11-28|2021-10-15|北京梆梆安全科技有限公司|Stack security detection method and device and mobile device|
    法律状态:
    2015-10-23| PLFP| Fee payment|Year of fee payment: 3 |
    2016-10-28| PLFP| Fee payment|Year of fee payment: 4 |
    2017-10-26| PLFP| Fee payment|Year of fee payment: 5 |
    2018-10-26| PLFP| Fee payment|Year of fee payment: 6 |
    2019-10-29| PLFP| Fee payment|Year of fee payment: 7 |
    2020-10-26| PLFP| Fee payment|Year of fee payment: 8 |
    2021-11-09| PLFP| Fee payment|Year of fee payment: 9 |
    优先权:
    申请号 | 申请日 | 专利标题
    FR1302695A|FR3013869B1|2013-11-22|2013-11-22|METHOD FOR DETECTING BATTERY FLOWS AND PROCESSOR FOR IMPLEMENTING SUCH A METHOD|FR1302695A| FR3013869B1|2013-11-22|2013-11-22|METHOD FOR DETECTING BATTERY FLOWS AND PROCESSOR FOR IMPLEMENTING SUCH A METHOD|
    US14/550,834| US9513911B2|2013-11-22|2014-11-21|Method of detecting stack overflows and processor for implementing such a method|
    [返回顶部]